home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 February: Technology Seed / Mac Tech Seed Feb '97.toast / OpenDoc 1.2b2c1 / TestParts / DragText / DragSI.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-01  |  13.0 KB  |  409 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        SemtIntf.cpp
  3.  
  4.     Contains:    Implementation of SemtIntf class.
  5.  
  6.     Owned by:    Nick Pilch
  7.  
  8.     Copyright:    © 1994 - 1996 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.  
  12.          <2>     5/24/96    jpa        1246074: Added a missing SOM_CATCH_ALL.
  13.  
  14.     To Do:
  15.     In Progress:
  16.         
  17. */
  18.  
  19.  
  20. #ifndef _EXCEPT_
  21. #include "Except.h"
  22. #endif
  23.  
  24. #ifndef _ODDESUTL_
  25. #include <ODDesUtl.h>
  26. #endif
  27.  
  28. #ifndef SOM_ODOSLToken_xh
  29. #include "ODOSLTkn.xh"
  30. #endif
  31.  
  32. #ifndef SOM_ODAppleEvent_xh
  33. #include "ODAplEvt.xh"
  34. #endif
  35.  
  36. #ifndef _ODREGISTRY_
  37. #include "ODRgstry.xh"
  38. #endif
  39.  
  40. #ifndef _SEUTILS_
  41. #include <SEUtils.h>
  42. #endif
  43.  
  44. #ifndef SOM_ODNameResolver_xh
  45. #include <NamRslvr.xh>
  46. #endif
  47.  
  48. #ifndef SOM_ODSession_xh
  49. #include <ODSessn.xh>
  50. #endif
  51.  
  52. #ifndef _TEMPOBJ_
  53. #include "TempObj.h"
  54. #endif
  55.  
  56. #define VARIABLE_MACROS
  57. #define AppleTestDrag_SemtIntf_Class_Source
  58. #include <DragSI.xih>
  59.  
  60. #pragma segment SemtIntf
  61.  
  62. //------------------------------------------------------------------------------
  63. // SemtIntf::InitSemtIntf
  64. //------------------------------------------------------------------------------
  65.  
  66. SOM_Scope void  SOMLINK AppleTestDrag_SemtIntfInitSemtIntf(AppleTestDrag_SemtIntf *somSelf, Environment *ev,
  67.         ODPart* base,
  68.         ODSession* session)
  69. {
  70.     AppleTestDrag_SemtIntfData *somThis = AppleTestDrag_SemtIntfGetData(somSelf);
  71.     AppleTestDrag_SemtIntfMethodDebug("AppleTestDrag_SemtIntf","AppleTestDrag_SemtIntfInitSemtIntf");
  72.  
  73.     _fSession = session;
  74.  
  75.     SOM_TRY
  76.         somSelf->InitSemanticInterface(ev, base, session);
  77.     SOM_CATCH_ALL
  78.     SOM_ENDTRY
  79. }
  80.  
  81. //------------------------------------------------------------------------------
  82. // SemtIntf::CallEventHandler
  83. //------------------------------------------------------------------------------
  84.  
  85. SOM_Scope void  SOMLINK AppleTestDrag_SemtIntfCallEventHandler(AppleTestDrag_SemtIntf *somSelf, Environment *ev,
  86.         ODPart* thePart,
  87.         ODAppleEvent* theODAppleEvent,
  88.         ODAppleEvent* reply)
  89. {
  90.     AppleTestDrag_SemtIntfMethodDebug("AppleTestDrag_SemtIntf","AppleTestDrag_SemtIntfCallEventHandler");
  91.  
  92.     // IF WE ARE CAREFUL TO INITIALIZE OUR AEDESCs (AND AppleEvents, ETC.) TO
  93.     //    NULL DESCRIPTORS, THEN WE CAN SAFELY CALL DISPOSAL ROUTINES
  94.     //    (AEDisposeDesc, ODDisposeAppleEvent) ON THEM BECAUSE THE DISPOSAL
  95.     //    ROUTINES IGMORE NULL DESCRIPTORS.
  96.  
  97.     AppleEvent messageAsAEDesc = NULL_DESCRIPTOR_DEFINITION;
  98.     AppleEvent replyAsAEDesc = NULL_DESCRIPTOR_DEFINITION;
  99.  
  100.     SOM_TRY
  101.         // ODEXTENSION SUBCLASSES MUST CALL THIS METHOD AT THE BEGINNING OF
  102.         //    EACH PUBLIC METHOD
  103.         somSelf->CheckValid(ev);
  104.  
  105.         // THIS IMPLEMENTATION IS ONLY A SKELETON. SO WE RETURN
  106.         //    errAEEventNotHandled TO LET OPENDOC KNOW THAT WE DON'T HANDLE
  107.         //    ANY EVENTS YET.
  108.         THROW(errAEEventNotHandled);
  109.  
  110.         // CREATE AN AppleEvent THAT WE CAN LOOK AT FROM THE ODAppleEvent.
  111.         THROW_IF_ERROR( ODDescToAEDesc(theODAppleEvent, &messageAsAEDesc) );
  112.  
  113.         // GET THE EVENT CLASS AND ID SO THAT WE CAN DECIDE WHAT CODE TO INVOKE.
  114.         AEEventClass eventClass = (AEEventClass)GetSLongAttr(
  115.                     &messageAsAEDesc, keyEventClassAttr);
  116.         AEEventID eventID = (AEEventID)GetSLongAttr(
  117.                     &messageAsAEDesc, keyEventIDAttr);
  118.  
  119.         /* WE CAN GET OTHER PARAMETERS/ATTRIBUTES OUT OF THE EVENT HERE AND/OR
  120.             DISPATCH NOW TO THE APPROPRIATE CODE, e.g.:
  121.             
  122.             if (eventClass == myEventClass && eventID == myDoSomethingEventID)
  123.                 CallMyDoSomethingProc(...);
  124.             else if (eventClass == myEventClass
  125.                         && eventID == myDoSomethingElseEventID)
  126.                 CallMyDoSomethingElseProc(...);
  127.             else
  128.                 THROW(errAEEventNotHandled);
  129.         */
  130.  
  131.         // IF WE NEED TO PLACE THINGS IN THE REPLY PARAMETER, WE NEED TO GET
  132.         //    AN AppleEvent FROM THE ODAppleEvent IN ORDER TO BE ABLE TO USE
  133.         //    AEPutParamPtr, ETC.
  134.         THROW_IF_ERROR( ODDescToAEDesc(reply, &replyAsAEDesc) );
  135.  
  136.         // IF WE HAVE PUT SOMETHING INTO THE REPLY AppleEvent, WE NEED TO PUT
  137.         //    THIS INFO BACK INTO THE ODAppleEvent
  138.         THROW_IF_ERROR( AEDescToODDesc(&replyAsAEDesc, reply) );
  139.  
  140.         // DISPOSE OUR LOCAL COPIES OF THESE AppleEvents. THIS IS VERY IMPORTANT.
  141.         //    THESE THINGS ARE BIG! YOU DON'T WANT TO LEAK THESE. WE USE THE
  142.         //    UTILITY ODDisposeAppleEvent SINCE THESE APPLE EVENTS WILL SOMETIMES
  143.         //    APPEAR "LIVE" TO THE APPLE EVENT MANAGER AND IT WILL REFUSE TO
  144.         //    DISPOSE THEM. ODDisposeAppleEvent TAKES CARE OF THIS.
  145.         ODDisposeAppleEvent(&replyAsAEDesc);
  146.         ODDisposeAppleEvent(&messageAsAEDesc);
  147.     SOM_CATCH_ALL
  148.         ODDisposeAppleEvent(&replyAsAEDesc);
  149.         ODDisposeAppleEvent(&messageAsAEDesc);
  150.     SOM_ENDTRY
  151. }
  152.  
  153. //------------------------------------------------------------------------------
  154. // SemtIntf::CallCoercionHandler
  155. //------------------------------------------------------------------------------
  156.  
  157. SOM_Scope void  SOMLINK AppleTestDrag_SemtIntfCallCoercionHandler(AppleTestDrag_SemtIntf *somSelf, Environment *ev,
  158.         ODPart* thePart,
  159.         ODDesc* theODDesc,
  160.         ODDescType toType,
  161.         ODDesc* result)
  162. {
  163.     AppleTestDrag_SemtIntfData *somThis = AppleTestDrag_SemtIntfGetData(somSelf);
  164.     AppleTestDrag_SemtIntfMethodDebug("AppleTestDrag_SemtIntf","AppleTestDrag_SemtIntfCallCoercionHandler");
  165.  
  166.     SOM_TRY
  167.         somSelf->CheckValid(ev);
  168.  
  169.         // THIS IMPLEMENTATION IS ONLY A SKELETON. SO WE RETURN
  170.         //    errAEEventNotHandled TO LET OPENDOC KNOW THAT WE DON'T HANDLE
  171.         //    ANY COERCIONS YET.
  172.         THROW(errAECoercionFail);
  173.  
  174.         // CONVERT ODDesc INPUT INTO AEDesc
  175.         AEDesc    inDescAsAEDesc;
  176.         THROW_IF_ERROR( ODDescToAEDesc(theODDesc, &inDescAsAEDesc));
  177.         // PROTECT AEDesc WITH A TEMP OBJECT.
  178.         TempAEDesc    tmpDesc1(&inDescAsAEDesc);
  179.  
  180.         // DO YOUR COERCION HERE. CHECK inDescAsAEDesc.descriptorType TO SEE IF
  181.         //    YOU CAN/WANT TO HANDLE THE TYPE.
  182.  
  183.         // CREATE OUTPUT AEDesc
  184.         AEDesc        outDesc = NULL_DESCRIPTOR_DEFINITION;
  185.         TempAEDesc    tmpDesc2(&outDesc);
  186.  
  187.         // PLACE DATA INTO OUTPUT AEDesc
  188.         
  189.         // PUT OUTPUT AEDesc INTO THE ODDesc
  190.         THROW_IF_ERROR( AEDescToODDesc( &outDesc, result ));
  191.     SOM_CATCH_ALL
  192.     SOM_ENDTRY
  193. }
  194.  
  195. //------------------------------------------------------------------------------
  196. // SemtIntf::CallObjectAccessor
  197. //------------------------------------------------------------------------------
  198.  
  199. SOM_Scope void  SOMLINK AppleTestDrag_SemtIntfCallObjectAccessor(AppleTestDrag_SemtIntf *somSelf, Environment *ev,
  200.         ODPart* thePart,
  201.         ODDescType desiredClass,
  202.         ODOSLToken* container,
  203.         ODDescType containerClass,
  204.         ODDescType form,
  205.         ODDesc* selectionData,
  206.         ODOSLToken* value)
  207. {
  208.     AppleTestDrag_SemtIntfData *somThis = AppleTestDrag_SemtIntfGetData(somSelf);
  209.     AppleTestDrag_SemtIntfMethodDebug("AppleTestDrag_SemtIntf","AppleTestDrag_SemtIntfCallObjectAccessor");
  210.  
  211.     SOM_TRY
  212.         somSelf->CheckValid(ev);
  213.  
  214.         // THIS IMPLEMENTATION IS ONLY A SKELETON. SO WE RETURN
  215.         //    errAEEventNotHandled TO LET OPENDOC KNOW THAT WE DON'T HANDLE
  216.         //    ANY OBJECT ACCESSES YET.
  217.         THROW(errAEEventNotHandled);
  218.  
  219.         AEDesc            containerAEDesc = NULL_DESCRIPTOR_DEFINITION;
  220.         DescType        containerType = typeNull;
  221.         ODNameResolver*    resolver = _fSession->GetNameResolver(ev);
  222.  
  223.         // GET THE USER TOKEN OUT OF THE CONTAINER
  224.         ODDesc* userTokenWrapper = resolver->GetUserToken(ev, container);
  225.         THROW_IF_ERROR(ODDescToAEDesc(userTokenWrapper, &containerAEDesc ));
  226.         TempAEDesc    tempDesc1(&containerAEDesc);
  227.         containerType = containerAEDesc.descriptorType;
  228.  
  229.         AEDesc    resultAEDesc = NULL_DESCRIPTOR_DEFINITION;
  230.         TempAEDesc    tempDesc2(&resultAEDesc);
  231.  
  232.         // EXAMINE containerType AND desiredClass TO DETERMINE IF YOU WANT TO
  233.         //    HANDLE THIS OBJECT ACCESS AND CALL THE APPROPRIATE OBJECT ACCESSING
  234.         //    ROUTINE
  235.  
  236.         // PLACE THE RESULT BACK INTO THE ODDesc.
  237.         AEDescToODDesc(&resultAEDesc, userTokenWrapper);
  238.     SOM_CATCH_ALL
  239.     SOM_ENDTRY
  240. }
  241.  
  242. //------------------------------------------------------------------------------
  243. // SemtIntf::CallCompareProc
  244. //------------------------------------------------------------------------------
  245.  
  246. SOM_Scope void  SOMLINK AppleTestDrag_SemtIntfCallCompareProc(AppleTestDrag_SemtIntf *somSelf, Environment *ev,
  247.         ODPart* thePart,
  248.         ODDescType oper,
  249.         ODOSLToken* obj1,
  250.         ODOSLToken* obj2,
  251.         ODBoolean* result)
  252. {
  253.     AppleTestDrag_SemtIntfData *somThis = AppleTestDrag_SemtIntfGetData(somSelf);
  254.     AppleTestDrag_SemtIntfMethodDebug("AppleTestDrag_SemtIntf","AppleTestDrag_SemtIntfCallCompareProc");
  255.  
  256.     SOM_TRY
  257.         somSelf->CheckValid(ev);
  258.  
  259.         // THIS IMPLEMENTATION IS ONLY A SKELETON. SO WE RETURN
  260.         //    errAEEventNotHandled TO LET OPENDOC KNOW THAT WE DON'T HANDLE
  261.         //    ANY OBJECT ACCESSES YET.
  262.         THROW(errAEEventNotHandled);
  263.  
  264.         ODNameResolver*    resolver = _fSession->GetNameResolver(ev);
  265.         
  266.         // CHECK TO SEE WHETHER SECOND OBJECT IS A TOKEN OR JUST A DATA
  267.         //    DESCRIPTOR.
  268.         ODBoolean        isODToken = resolver->IsODToken(ev, obj2);
  269.  
  270.         // DO WHAT YOU HAVE TO DO TO RUN THE COMPARISON.
  271.  
  272.         // MAKE SURE TO SET THE RESULT.
  273.         *result = kODFalse;
  274.     SOM_CATCH_ALL
  275.     SOM_ENDTRY
  276. }
  277.  
  278. //------------------------------------------------------------------------------
  279. // SemtIntf::CallCountProc
  280. //------------------------------------------------------------------------------
  281.  
  282. SOM_Scope void  SOMLINK AppleTestDrag_SemtIntfCallCountProc(AppleTestDrag_SemtIntf *somSelf, Environment *ev,
  283.         ODPart* thePart,
  284.         ODDescType desiredType,
  285.         ODDescType containerClass,
  286.         ODOSLToken* container,
  287.         ODSLong* result)
  288. {
  289.     AppleTestDrag_SemtIntfData *somThis = AppleTestDrag_SemtIntfGetData(somSelf);
  290.     AppleTestDrag_SemtIntfMethodDebug("AppleTestDrag_SemtIntf","AppleTestDrag_SemtIntfCallCountProc");
  291.  
  292.     SOM_TRY
  293.         somSelf->CheckValid(ev);
  294.  
  295.         // THIS IMPLEMENTATION IS ONLY A SKELETON. SO WE RETURN
  296.         //    errAEEventNotHandled TO LET OPENDOC KNOW THAT WE DON'T HANDLE
  297.         //    THIS METHOD YET.
  298.         THROW(errAEEventNotHandled);
  299.  
  300.         // IMPLEMENTATION HERE.
  301.     SOM_CATCH_ALL
  302.     SOM_ENDTRY
  303. }
  304.  
  305. //------------------------------------------------------------------------------
  306. // SemtIntf::CallDisposeTokenProc
  307. //------------------------------------------------------------------------------
  308.  
  309. SOM_Scope void  SOMLINK AppleTestDrag_SemtIntfCallDisposeTokenProc(AppleTestDrag_SemtIntf *somSelf, Environment *ev,
  310.         ODPart* thePart,
  311.         ODOSLToken* unneededToken)
  312. {
  313.     AppleTestDrag_SemtIntfData *somThis = AppleTestDrag_SemtIntfGetData(somSelf);
  314.     AppleTestDrag_SemtIntfMethodDebug("AppleTestDrag_SemtIntf","AppleTestDrag_SemtIntfCallDisposeTokenProc");
  315.  
  316.     SOM_TRY
  317.         somSelf->CheckValid(ev);
  318.  
  319.         // THIS IMPLEMENTATION IS ONLY A SKELETON. SO WE RETURN
  320.         //    errAEEventNotHandled TO LET OPENDOC KNOW THAT WE DON'T HANDLE
  321.         //    THIS METHOD YET.
  322.         THROW(errAEEventNotHandled);
  323.  
  324.         // ONLY HANDLE IF IT IS AN OPENDOC TOKEN. SOMETIMES TOKENS THAT OPENDOC
  325.         //    USES INTERNALLY ARE PASSED TO PARTS TO DISPOSE. YOU SHOULD LET
  326.         //    OPENDOC DISPOSE THESE.
  327.         ODNameResolver* resolver = _fSession->GetNameResolver(ev);
  328.         if ( resolver->IsODToken( ev, unneededToken ) )
  329.         {
  330.             // GET THE USER TOKEN AND ITS TYPE
  331.             ODDesc* userTokenODDesc = resolver->GetUserToken( ev, unneededToken );
  332.             AEDesc tokenAsAEDesc;
  333.             THROW_IF_ERROR(ODDescToAEDesc(userTokenODDesc, &tokenAsAEDesc ));
  334.             TempAEDesc    tempDesc1(&tokenAsAEDesc);
  335.             DescType tokenType = tokenAsAEDesc.descriptorType;
  336.     
  337.             // IF YOU SUPPORT LIST OF TOKENS, YOU SHOULD ITERATE OVER THE LIST
  338.             //    AND CALL BACK TO ODNAMERESOLVER::DISPOSETOKEN FOR EACH TOKEN
  339.             if ( tokenType == typeAEList )
  340.             {
  341.                 long count;
  342.                 THROW_IF_ERROR( AECountItems( &tokenAsAEDesc, &count ) );
  343.     
  344.                 for ( ODUShort index = 1; index <= count ; ++index )
  345.                 {
  346.                     // IF YOU CONVERTED THE CONTAINED TOKENS INTO AEDescs AND
  347.                     //    THEN PUT THEM INTO AN AEDescList, THEN YOU WILL HAVE
  348.                     //    TO CONVERT THEM BACK TO ODOSLTokens BEFORE YOU CALL
  349.                     //    DIPOSETOKEN.
  350.                     AEDesc        oneToken;
  351.                     DescType    tokenDescType;
  352.                     THROW_IF_ERROR( AEGetNthDesc( &tokenAsAEDesc, index, typeWildCard,
  353.                             &tokenDescType, &oneToken ) );
  354.                     ODOSLToken* subToken = new ODOSLToken();
  355.                     THROW_IF_NULL(subToken);
  356.                     subToken->InitODOSLToken(ev);
  357.                     THROW_IF_ERROR( AEDescToODDesc( &oneToken, subToken ) );
  358.                     (void)AEDisposeDesc( &oneToken );
  359.  
  360.                     // MAKE SURE TO CALL OPENDOC TO DISPOSE THE TOKEN.
  361.                     TRY    
  362.                         resolver->DisposeToken( ev, subToken );
  363.                     CATCH_ALL
  364.                     ENDTRY
  365.                 }
  366.             }
  367.             else
  368.             {
  369.                 // YOU COULD HANDLE PRIVATE TOKEN TYPES HERE.
  370.             }
  371.         }
  372.  
  373.         // LET OPENDOC DISPOSE unneededToken ITSELF. WE ONLY HANDLED DEALING
  374.         //    WITH OUR INTERNAL STRUCTURES. ALTERNATIVELY, YOU CAN delete
  375.         //    unneededToken YOURSELF AS WELL. LETTING OPENDOC DO IT MAKES ERROR
  376.         //    HANDLING SLIGHTLY EASIER
  377.         THROW(errAEEventNotHandled);
  378.     SOM_CATCH_ALL
  379.     SOM_ENDTRY
  380. }
  381.  
  382. //------------------------------------------------------------------------------
  383. // SemtIntf::CallGetErrDescProc
  384. //------------------------------------------------------------------------------
  385.  
  386. SOM_Scope void  SOMLINK AppleTestDrag_SemtIntfCallGetErrDescProc(AppleTestDrag_SemtIntf *somSelf, Environment *ev,
  387.         ODPart* thePart,
  388.         ODDesc** errDesc)
  389. {
  390.     AppleTestDrag_SemtIntfData *somThis = AppleTestDrag_SemtIntfGetData(somSelf);
  391.     AppleTestDrag_SemtIntfMethodDebug("AppleTestDrag_SemtIntf","AppleTestDrag_SemtIntfCallGetErrDescProc");
  392.  
  393.     SOM_TRY
  394.         somSelf->CheckValid(ev);
  395.         
  396.         // THIS IMPLEMENTATION IS ONLY A SKELETON. SO WE RETURN
  397.         //    errAEEventNotHandled TO LET OPENDOC KNOW THAT WE DON'T HANDLE
  398.         //    THIS METHOD YET.
  399.         THROW(errAEEventNotHandled);
  400.  
  401.         // ALLOCATE AN ODDESC FOR ERROR REPORTING. YOU MUST DELETE THIS ODDESC
  402.         //    ONCE THE EVENT IS COMPLETELY PROCESSED.
  403.         *errDesc = new ODDesc;
  404.         (*errDesc)->InitODDesc(ev);
  405.     SOM_CATCH_ALL
  406.     SOM_ENDTRY
  407. }
  408.  
  409.